package com.yuntsg.nnsfcp.service.front;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.yuntsg.nnsfcp.front.entity.UserInfo;
import com.yuntsg.nnsfcp.front.mapper.UserInfoMapper;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;

/**
 * 各种校验
 *
 * @author ：ljx
 * @date ：Created in 2019/9/26
 */
@Component
public class CheckService {

    @Resource
    private UserInfoMapper userInfoMapper;


    /**
     * 判断是否是数字
     *
     * @param str 字符串
     * @return
     */
    public boolean checkIsNum(String str) {
        return Pattern.matches("^[-\\+]?[\\d]*$", str);
    }

    /**
     * 校验邮箱
     *
     * @param email 邮箱
     * @return
     */
    public boolean checkIsEmail(String email) {
        String regEx = "^([a-z0-9A-Z]+[-|\\.]?)+[a-z0-9A-Z]@([a-z0-9A-Z]+(-[a-z0-9A-Z]+)?\\.)+[a-zA-Z]{2,}$";
        return Pattern.matches(regEx, email);
    }

    /**
     * 判断字符串中 是否是 字母+ 数字的一个组合
     *
     * @param str 字符串
     * @return
     */
    public boolean checkAbcAndNum(String str) {
        String regEx = "^(?![0-9]+$)(?![a-z]+$)(?![A-Z]+$)(?!([^(0-9a-zA-Z)])+$).{6,16}$";
        return Pattern.matches(regEx, str);
    }

    /**
     * 判断字符串中是否有特殊符号
     *
     * @param str 字符串
     * @return
     */
    public boolean checkSpecial(String str) {
        String regEx = "[`~!@#$%^&*()+=|{}':;',\\\\\\\\[\\\\\\\\].<>/?~！@#￥%……&*（）——+|{}【】‘；：”“’。，、？-]";
        Pattern compile = Pattern.compile(regEx);
        Matcher matcher = compile.matcher(str);
        return matcher.find();
    }

    /**
     * 纳税人识别号.
     *
     * @param num 识别号
     * @return
     */
    public boolean checkInvoiceNum(String num) {
        String regEx = "^[A-Z0-9]{15}$|^[A-Z0-9]{18}$|^[A-Z0-9]{20}$";
        return Pattern.matches(regEx, num);
    }


    /**
     * 大陆号码或香港号码均可
     */
    public boolean checkIsPhone(String str) throws PatternSyntaxException {
        return isChinaPhoneLegal(str) || isHKPhoneLegal(str);
    }

    /**
     * 大陆手机号码11位数，匹配格式：前三位固定格式+后8位任意数
     * 此方法中前三位格式有：
     * 13+任意数
     * 15+除4的任意数
     * 18+除1和4的任意数
     * 17+除9的任意数
     * 147
     */
    private boolean isChinaPhoneLegal(String str) throws PatternSyntaxException {
        String regExp = "^((13[0-9])|(15[^4])|(18[0,2,3,5-9])|(17[0-8])|(147))\\d{8}$";
        Pattern p = Pattern.compile(regExp);
        Matcher m = p.matcher(str);
        return m.matches();
    }

    /**
     * 香港手机号码8位数，5|6|8|9开头+7位任意数
     */
    private boolean isHKPhoneLegal(String str) throws PatternSyntaxException {
        String regExp = "^(5|6|8|9)\\d{7}$";
        Pattern p = Pattern.compile(regExp);
        Matcher m = p.matcher(str);
        return m.matches();
    }

    /**
     * 判断密码安全
     *
     * @param pass 密码
     * @return
     */
    public boolean checkPassSelf(String pass) {
        String reg = "^.*(?=.{6,})(?=.*\\d)(?=.*[A-Z])(?=.*[a-z])(?=.*[!@#$%^&*? ]).*$";
        return Pattern.matches(reg, pass);
    }

    /**
     * 判断字符串长度
     *
     * @param str    字符串
     * @param length 要判断的长度
     * @return
     */
    public boolean checkLength(String str, Integer length) {
        if (length.equals(str.length())) {
            return true;
        }
        return false;
    }

    /**
     * 检查账号重复
     *
     * @param str 字符串
     * @return
     */
    public boolean checkAccountReg(String str) {
        //查询账户
        UserInfo user = null;
        user = userInfoMapper.selectOne(new QueryWrapper<UserInfo>()
                .eq("account", str).eq("is_delete", 0));
        if (user != null) {
            user = null;
            return false;
        }
        return true;
    }

    /**
     * 检查手机号是否注册过
     *
     * @param str
     * @return
     */
    public boolean checkPhoneReg(String str) {

        boolean ifNum = checkIsNum(str);

        //查询手机号码
        if (str.length() == 11 && ifNum) {
            boolean boo = checkIsPhone(str);
            if (!boo) {
                return false;
            }

            UserInfo user = userInfoMapper.selectOne(new QueryWrapper<UserInfo>()
                    .eq("phone", str).eq("is_delete", 0));

            if (user != null) {
                return false;
            }
            user = null;
        }
        return true;
    }


    /**
     * 校验银行卡卡号
     *
     * @param cardId
     * @return
     */
    public boolean checkBankCard(String cardId) {
        char bit = getBankCardCheckCode(cardId.substring(0, cardId.length() - 1));
        if (bit == 'N') {
            return false;
        }
        return cardId.charAt(cardId.length() - 1) == bit;
    }

    /**
     * 从不含校验位的银行卡卡号采用 Luhm 校验算法获得校验位
     *
     * @param nonCheckCodeCardId
     * @return
     */
    private char getBankCardCheckCode(String nonCheckCodeCardId) {
        if (nonCheckCodeCardId == null || nonCheckCodeCardId.trim().length() == 0
                || !nonCheckCodeCardId.matches("\\d+")) {
            //如果传的不是数据返回N
            return 'N';
        }
        char[] chs = nonCheckCodeCardId.trim().toCharArray();
        int luhmSum = 0;
        for (int i = chs.length - 1, j = 0; i >= 0; i--, j++) {
            int k = chs[i] - '0';
            if (j % 2 == 0) {
                k *= 2;
                k = k / 10 + k % 10;
            }
            luhmSum += k;
        }
        return (luhmSum % 10 == 0) ? '0' : (char) ((10 - luhmSum % 10) + '0');
    }

    /**
     * 匹配字符串中是否包含特殊符号 及 数字
     *
     * @param str
     * @return 存在为true
     */
    public boolean checkName(String str) {
        String regEx = "[`~!@#$%^&*()+=|{}':;',\\[\\].<>/?~！@#￥%……&*（）——+|{}【】‘；：”“’。，、？]";
        String regEx2 = "[1234567890]";
        Pattern p = Pattern.compile(regEx);
        Pattern p2 = Pattern.compile(regEx2);
        Matcher m = p.matcher(str);
        Matcher m2 = p2.matcher(str);
        boolean b = m.find();
        boolean b1 = m2.find();
        if (!b && !b1) {
            return true;
        }
        return false;
    }

}
